home *** CD-ROM | disk | FTP | other *** search
/ Programming Windows (5th Edition) / Programming Windows, 5th ed. - Companion CD (097-0002183)(1999).iso / Chap16 / Dibble / DibHelp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-09  |  30.8 KB  |  1,124 lines
  1. /*------------------------------------------
  2.    DIBHELP.C -- DIB Section Helper Routines 
  3.                 (c) Charles Petzold, 1998
  4.   ------------------------------------------*/
  5.  
  6. #define WINVER 0x0500
  7. #include <windows.h>
  8. #include "dibhelp.h"
  9.  
  10. #define HDIB_SIGNATURE (* (int *) "Dib ")
  11.  
  12. typedef struct
  13. {
  14.      PBYTE    * ppRow ;            // must be first field for macros!
  15.      int        iSignature ;
  16.      HBITMAP    hBitmap ;
  17.      BYTE     * pBits ;
  18.      DIBSECTION ds ;
  19.      int        iRShift[3] ;
  20.      int        iLShift[3] ;
  21. }
  22. DIBSTRUCT, * PDIBSTRUCT ;
  23.  
  24. /*---------------------------------------------------------------
  25.    DibIsValid:  Returns TRUE if hdib points to a valid DIBSTRUCT
  26.   ---------------------------------------------------------------*/
  27.  
  28. BOOL DibIsValid (HDIB hdib)
  29. {
  30.      PDIBSTRUCT pdib = hdib ;
  31.  
  32.      if (pdib == NULL)
  33.           return FALSE ;
  34.  
  35.      if (IsBadReadPtr (pdib, sizeof (DIBSTRUCT)))
  36.           return FALSE ;
  37.  
  38.      if (pdib->iSignature != HDIB_SIGNATURE)
  39.           return FALSE ;
  40.  
  41.      return TRUE ;
  42. }
  43.  
  44. /*-----------------------------------------------------------------------
  45.    DibBitmapHandle:  Returns the handle to the DIB section bitmap object
  46.   -----------------------------------------------------------------------*/
  47.  
  48. HBITMAP DibBitmapHandle (HDIB hdib)
  49. {
  50.      if (!DibIsValid (hdib))
  51.           return NULL ;
  52.      
  53.      return ((PDIBSTRUCT) hdib)->hBitmap ;
  54. }
  55.  
  56. /*-------------------------------------------
  57.    DibWidth:  Returns the bitmap pixel width
  58.   -------------------------------------------*/
  59.  
  60. int DibWidth (HDIB hdib)
  61. {
  62.      if (!DibIsValid (hdib))
  63.           return 0 ;
  64.      
  65.      return ((PDIBSTRUCT) hdib)->ds.dsBm.bmWidth ;
  66. }
  67.  
  68. /*---------------------------------------------
  69.    DibHeight:  Returns the bitmap pixel height
  70.   ---------------------------------------------*/
  71.  
  72. int DibHeight (HDIB hdib)
  73. {
  74.      if (!DibIsValid (hdib))
  75.           return 0 ; 
  76.      
  77.      return ((PDIBSTRUCT) hdib)->ds.dsBm.bmHeight ;
  78. }
  79.  
  80. /*----------------------------------------------------
  81.    DibBitCount:  Returns the number of bits per pixel
  82.   ----------------------------------------------------*/
  83.  
  84. int DibBitCount (HDIB hdib)
  85. {
  86.      if (!DibIsValid (hdib))
  87.           return 0 ;
  88.      
  89.      return ((PDIBSTRUCT) hdib)->ds.dsBm.bmBitsPixel ;
  90. }
  91.  
  92. /*--------------------------------------------------------------
  93.    DibRowLength:  Returns the number of bytes per row of pixels
  94.   --------------------------------------------------------------*/
  95.  
  96. int DibRowLength (HDIB hdib)
  97. {
  98.      if (!DibIsValid (hdib))
  99.           return 0 ;
  100.      
  101.      return 4 * ((DibWidth (hdib) * DibBitCount (hdib) + 31) / 32) ;
  102. }
  103.  
  104. /*----------------------------------------------------------------
  105.    DibNumColors:  Returns the number of colors in the color table
  106.   ----------------------------------------------------------------*/
  107.  
  108. int DibNumColors (HDIB hdib)
  109. {
  110.      PDIBSTRUCT pdib = hdib ;
  111.  
  112.      if (!DibIsValid (hdib))
  113.           return 0 ;
  114.  
  115.      if (pdib->ds.dsBmih.biClrUsed != 0)
  116.      {
  117.           return pdib->ds.dsBmih.biClrUsed ;
  118.      }
  119.      else if (DibBitCount (hdib) <= 8)
  120.      {
  121.           return 1 << DibBitCount (hdib) ;
  122.      }
  123.      return 0 ;
  124. }
  125.  
  126. /*------------------------------------------
  127.    DibMask:  Returns one of the color masks
  128.   ------------------------------------------*/
  129.  
  130. DWORD DibMask (HDIB hdib, int i)
  131. {
  132.      PDIBSTRUCT pdib = hdib ;
  133.  
  134.      if (!DibIsValid (hdib) || i < 0 || i > 2)
  135.           return 0 ;
  136.      
  137.      return pdib->ds.dsBitfields[i] ;
  138. }
  139.  
  140. /*---------------------------------------------------
  141.    DibRShift:  Returns one of the right-shift values
  142.   ---------------------------------------------------*/
  143.  
  144. int DibRShift (HDIB hdib, int i)
  145. {
  146.      PDIBSTRUCT pdib = hdib ;
  147.  
  148.      if (!DibIsValid (hdib) || i < 0 || i > 2)
  149.           return 0 ;
  150.      
  151.      return pdib->iRShift[i] ;
  152. }
  153.  
  154. /*--------------------------------------------------
  155.    DibLShift:  Returns one of the left-shift values
  156.   --------------------------------------------------*/
  157.  
  158. int DibLShift (HDIB hdib, int i)
  159. {
  160.      PDIBSTRUCT pdib = hdib ;
  161.  
  162.      if (!DibIsValid (hdib) || i < 0 || i > 2)
  163.           return 0 ;
  164.      
  165.      return pdib->iLShift[i] ;
  166. }
  167.  
  168. /*---------------------------------------------------------------
  169.    DibCompression:  Returns the value of the biCompression field
  170.   ---------------------------------------------------------------*/
  171.  
  172. int DibCompression (HDIB hdib)
  173. {
  174.      if (!DibIsValid (hdib))
  175.           return 0 ;
  176.  
  177.      return ((PDIBSTRUCT) hdib)->ds.dsBmih.biCompression ;
  178. }
  179.  
  180. /*--------------------------------------------------------------
  181.    DibIsAddressable:  Returns TRUE if the DIB is not compressed
  182.   --------------------------------------------------------------*/
  183.  
  184. BOOL DibIsAddressable (HDIB hdib)
  185. {
  186.      int iCompression ;
  187.  
  188.      if (!DibIsValid (hdib))
  189.           return FALSE ;
  190.  
  191.      iCompression = DibCompression (hdib) ;
  192.  
  193.      if (iCompression == BI_RGB || iCompression == BI_BITFIELDS)
  194.          return TRUE ;
  195.  
  196.      return FALSE ;
  197. }
  198.  
  199. /*---------------------------------------------------------------------------
  200.    These functions return the sizes of various components of the DIB section
  201.      AS THEY WOULD APPEAR in a packed DIB. These functions aid in converting
  202.      the DIB section to a packed DIB and in saving DIB files.
  203.   ---------------------------------------------------------------------------*/
  204.  
  205. DWORD DibInfoHeaderSize (HDIB hdib)
  206. {
  207.      if (!DibIsValid (hdib))
  208.           return 0 ;
  209.  
  210.      return ((PDIBSTRUCT) hdib)->ds.dsBmih.biSize ;
  211. }
  212.  
  213. DWORD DibMaskSize (HDIB hdib)
  214. {
  215.      PDIBSTRUCT pdib = hdib ;
  216.  
  217.      if (!DibIsValid (hdib))
  218.           return 0 ;
  219.  
  220.      if (pdib->ds.dsBmih.biCompression == BI_BITFIELDS)
  221.           return 3 * sizeof (DWORD) ;
  222.  
  223.      return 0 ;
  224. }
  225.  
  226. DWORD DibColorSize (HDIB hdib)
  227. {
  228.      return DibNumColors (hdib) * sizeof (RGBQUAD) ;
  229. } 
  230.  
  231. DWORD DibInfoSize (HDIB hdib)
  232. {
  233.      return DibInfoHeaderSize(hdib) + DibMaskSize(hdib) + DibColorSize(hdib) ;
  234. }
  235.  
  236. DWORD DibBitsSize (HDIB hdib)
  237. {
  238.      PDIBSTRUCT pdib = hdib ;
  239.  
  240.      if (!DibIsValid (hdib))
  241.           return 0 ;
  242.  
  243.      if (pdib->ds.dsBmih.biSizeImage != 0)
  244.      {
  245.           return pdib->ds.dsBmih.biSizeImage ;
  246.      }
  247.      return DibHeight (hdib) * DibRowLength (hdib) ;
  248. }
  249.  
  250. DWORD DibTotalSize (HDIB hdib)
  251. {
  252.      return DibInfoSize (hdib) + DibBitsSize (hdib) ;
  253. }
  254.  
  255. /*----------------------------------------------------------------------
  256.    These functions return pointers to the various components of the DIB 
  257.      section.
  258.   ----------------------------------------------------------------------*/
  259.  
  260. BITMAPINFOHEADER * DibInfoHeaderPtr (HDIB hdib)
  261. {
  262.      if (!DibIsValid (hdib))
  263.           return NULL ;
  264.      
  265.      return & (((PDIBSTRUCT) hdib)->ds.dsBmih) ;
  266. }
  267.  
  268. DWORD * DibMaskPtr (HDIB hdib)
  269. {
  270.      PDIBSTRUCT pdib = hdib ;
  271.  
  272.      if (!DibIsValid (hdib))
  273.           return 0 ;
  274.  
  275.      return pdib->ds.dsBitfields ;
  276. }
  277.  
  278. void * DibBitsPtr (HDIB hdib)
  279. {
  280.      if (!DibIsValid (hdib))
  281.           return NULL ;
  282.      
  283.      return ((PDIBSTRUCT) hdib)->pBits ;
  284. }
  285.  
  286. /*------------------------------------------------------
  287.    DibSetColor:  Obtains entry from the DIB color table
  288.   ------------------------------------------------------*/
  289.  
  290. BOOL DibGetColor (HDIB hdib, int index, RGBQUAD * prgb)
  291. {
  292.      PDIBSTRUCT pdib = hdib ;
  293.      HDC        hdcMem ;
  294.      int        iReturn ;
  295.  
  296.      if (!DibIsValid (hdib))
  297.           return 0 ;
  298.  
  299.      hdcMem = CreateCompatibleDC (NULL) ;
  300.      SelectObject (hdcMem, pdib->hBitmap) ;
  301.      iReturn = GetDIBColorTable (hdcMem, index, 1, prgb) ;
  302.      DeleteDC (hdcMem) ;
  303.  
  304.      return iReturn ? TRUE : FALSE ;
  305. }
  306.  
  307. /*----------------------------------------------------
  308.    DibGetColor:  Sets an entry in the DIB color table
  309.   ----------------------------------------------------*/
  310.  
  311. BOOL DibSetColor (HDIB hdib, int index, RGBQUAD * prgb)
  312. {
  313.      PDIBSTRUCT pdib = hdib ;
  314.      HDC        hdcMem ;
  315.      int        iReturn ;
  316.  
  317.      if (!DibIsValid (hdib))
  318.           return 0 ;
  319.  
  320.      hdcMem = CreateCompatibleDC (NULL) ;
  321.      SelectObject (hdcMem, pdib->hBitmap) ;
  322.      iReturn = SetDIBColorTable (hdcMem, index, 1, prgb) ;
  323.      DeleteDC (hdcMem) ;
  324.  
  325.      return iReturn ? TRUE : FALSE ;
  326. }
  327.  
  328. /*-----------------------------------------------------------------
  329.    DibPixelPtr:  Returns a pointer to the pixel at position (x, y)
  330.   -----------------------------------------------------------------*/
  331.  
  332. BYTE * DibPixelPtr (HDIB hdib, int x, int y)
  333. {
  334.      if (!DibIsAddressable (hdib))
  335.           return NULL ;
  336.  
  337.      if (x < 0 || x >= DibWidth (hdib) || y < 0 || y >= DibHeight (hdib))
  338.           return NULL ;
  339.  
  340.      return (((PDIBSTRUCT) hdib)->ppRow)[y] + (x * DibBitCount (hdib) >> 3) ;
  341. }
  342.  
  343. /*-----------------------------------------------
  344.    DibGetPixel:  Obtains a pixel value at (x, y)
  345.   -----------------------------------------------*/
  346.  
  347. DWORD DibGetPixel (HDIB hdib, int x, int y)
  348. {
  349.      PBYTE pPixel ;
  350.  
  351.      if (!(pPixel = DibPixelPtr (hdib, x, y)))
  352.           return 0 ;
  353.  
  354.      switch (DibBitCount (hdib))
  355.      {
  356.      case  1:  return 0x01 & (* pPixel >> (7 - (x & 7))) ;
  357.      case  4:  return 0x0F & (* pPixel >> (x & 1 ? 0 : 4)) ;
  358.      case  8:  return * pPixel ;
  359.      case 16:  return * (WORD *) pPixel ;
  360.      case 24:  return 0x00FFFFFF & * (DWORD *) pPixel ; 
  361.      case 32:  return * (DWORD *) pPixel ;
  362.      }
  363.      return 0 ;
  364. }
  365.  
  366. /*--------------------------------------------
  367.    DibSetPixel:  Sets a pixel value at (x, y)
  368.   --------------------------------------------*/
  369.  
  370. BOOL DibSetPixel (HDIB hdib, int x, int y, DWORD dwPixel)
  371. {
  372.      PBYTE pPixel ;
  373.  
  374.      if (!(pPixel = DibPixelPtr (hdib, x, y)))
  375.           return FALSE ;
  376.  
  377.      switch (DibBitCount (hdib))
  378.      {
  379.      case  1:  * pPixel &= ~(1     << (7 - (x & 7))) ;
  380.                * pPixel |= dwPixel << (7 - (x & 7)) ;
  381.                break ;
  382.  
  383.      case  4:  * pPixel &= 0x0F    << (x & 1 ? 4 : 0) ;
  384.                * pPixel |= dwPixel << (x & 1 ? 0 : 4) ;
  385.                break ;
  386.  
  387.      case  8:  * pPixel = (BYTE) dwPixel ;
  388.                break ;
  389.  
  390.      case 16:  * (WORD *) pPixel = (WORD) dwPixel ;
  391.                break ;
  392.  
  393.      case 24:  * (RGBTRIPLE *) pPixel = * (RGBTRIPLE *) &dwPixel ; 
  394.                break ;
  395.  
  396.      case 32:  * (DWORD *) pPixel = dwPixel ;
  397.                break ;
  398.      default:
  399.           return FALSE ;
  400.      }
  401.      return TRUE ;
  402. }
  403.  
  404. /*------------------------------------------------------
  405.    DibGetPixelColor:  Obtains the pixel color at (x, y)
  406.   ------------------------------------------------------*/
  407.  
  408. BOOL DibGetPixelColor (HDIB hdib, int x, int y, RGBQUAD * prgb)
  409. {
  410.      DWORD      dwPixel ;
  411.      int        iBitCount ;
  412.      PDIBSTRUCT pdib = hdib ;
  413.  
  414.           // Get bit count; also use this as a validity check
  415.  
  416.      if (0 == (iBitCount = DibBitCount (hdib)))
  417.           return FALSE ;
  418.  
  419.           // Get the pixel value
  420.  
  421.      dwPixel = DibGetPixel (hdib, x, y) ;
  422.  
  423.           // If the bit-count is 8 or less, index the color table
  424.  
  425.      if (iBitCount <= 8)
  426.           return DibGetColor (hdib, (int) dwPixel, prgb) ;
  427.  
  428.           // If the bit-count is 24, just use the pixel
  429.  
  430.      else if (iBitCount == 24)
  431.      {
  432.           * (RGBTRIPLE *) prgb = * (RGBTRIPLE *) & dwPixel ;
  433.           prgb->rgbReserved = 0 ;
  434.      }
  435.  
  436.           // If the bit-count is 32 and the biCompression field is BI_RGB,
  437.           //   just use the pixel
  438.  
  439.      else if (iBitCount == 32 && 
  440.                pdib->ds.dsBmih.biCompression == BI_RGB)
  441.      {
  442.           * prgb = * (RGBQUAD *) & dwPixel ;
  443.      }
  444.  
  445.           // Otherwise, use the mask and shift values
  446.           //   (for best performance, don't use DibMask and DibShift functions)
  447.      else
  448.      {
  449.           prgb->rgbRed   = (BYTE) (((pdib->ds.dsBitfields[0] & dwPixel) 
  450.                                    >> pdib->iRShift[0]) << pdib->iLShift[0]) ;
  451.  
  452.           prgb->rgbGreen = (BYTE) (((pdib->ds.dsBitfields[1] & dwPixel) 
  453.                                    >> pdib->iRShift[1]) << pdib->iLShift[1]) ;
  454.  
  455.           prgb->rgbBlue  = (BYTE) (((pdib->ds.dsBitfields[2] & dwPixel) 
  456.                                    >> pdib->iRShift[2]) << pdib->iLShift[2]) ;
  457.      }
  458.      return TRUE ;
  459. }
  460.  
  461. /*---------------------------------------------------
  462.    DibSetPixelColor:  Sets the pixel color at (x, y) 
  463.   ---------------------------------------------------*/
  464.  
  465. BOOL DibSetPixelColor (HDIB hdib, int x, int y, RGBQUAD * prgb)
  466. {
  467.      DWORD      dwPixel ;
  468.      int        iBitCount ;
  469.      PDIBSTRUCT pdib = hdib ;
  470.  
  471.           // Don't do this function for DIBs with color tables
  472.  
  473.      iBitCount = DibBitCount (hdib) ;
  474.  
  475.      if (iBitCount <= 8)
  476.           return FALSE ;
  477.  
  478.           // The rest is just the opposite of DibGetPixelColor
  479.  
  480.      else if (iBitCount == 24)
  481.      {
  482.           * (RGBTRIPLE *) & dwPixel = * (RGBTRIPLE *) prgb ;
  483.           dwPixel &= 0x00FFFFFF ;
  484.      }
  485.  
  486.      else if (iBitCount == 32 &&
  487.                pdib->ds.dsBmih.biCompression == BI_RGB)
  488.      {
  489.           * (RGBQUAD *) & dwPixel = * prgb ;
  490.      }
  491.  
  492.      else
  493.      {
  494.           dwPixel  = (((DWORD) prgb->rgbRed >> pdib->iLShift[0]) 
  495.                          << pdib->iRShift[0]) ; 
  496.  
  497.           dwPixel |= (((DWORD) prgb->rgbGreen >> pdib->iLShift[1])
  498.                          << pdib->iRShift[1]) ; 
  499.  
  500.           dwPixel |= (((DWORD) prgb->rgbBlue >> pdib->iLShift[2])
  501.                          << pdib->iRShift[2]) ; 
  502.      }
  503.  
  504.      DibSetPixel (hdib, x, y, dwPixel) ;
  505.      return TRUE ;
  506. }
  507.  
  508. /*--------------------------------------------------------------
  509.    Calculating shift values from color masks is required by the 
  510.      DibCreateFromInfo function.
  511.   --------------------------------------------------------------*/
  512.  
  513. static int MaskToRShift (DWORD dwMask)
  514. {
  515.      int iShift ;
  516.  
  517.      if (dwMask == 0)
  518.           return 0 ;
  519.  
  520.      for (iShift = 0 ; !(dwMask & 1) ; iShift++)
  521.           dwMask >>= 1 ;
  522.  
  523.      return iShift ;
  524. }
  525.  
  526. static int MaskToLShift (DWORD dwMask)
  527. {
  528.      int iShift ;
  529.  
  530.      if (dwMask == 0)
  531.           return 0 ;
  532.  
  533.      while (!(dwMask & 1))
  534.           dwMask >>= 1 ;
  535.  
  536.      for (iShift = 0 ; dwMask & 1 ; iShift++)
  537.           dwMask >>= 1 ;
  538.  
  539.      return 8 - iShift ;
  540. }
  541.  
  542. /*-------------------------------------------------------------------------
  543.    DibCreateFromInfo: All DIB creation functions ultimately call this one.
  544.      This function is responsible for calling CreateDIBSection, allocating
  545.      memory for DIBSTRUCT, and setting up the row pointer.
  546.   -------------------------------------------------------------------------*/
  547.  
  548. HDIB DibCreateFromInfo (BITMAPINFO * pbmi)
  549. {
  550.      BYTE      * pBits ;
  551.      DIBSTRUCT * pdib ;
  552.      HBITMAP     hBitmap ;
  553.      int         i, iRowLength, cy, y ;
  554.      
  555.      hBitmap = CreateDIBSection (NULL, pbmi, DIB_RGB_COLORS, &pBits, NULL, 0) ;
  556.  
  557.      if (hBitmap == NULL)
  558.           return NULL ;
  559.  
  560.      if (NULL == (pdib = malloc (sizeof (DIBSTRUCT))))
  561.      {
  562.           DeleteObject (hBitmap) ;
  563.           return NULL ;
  564.      }
  565.  
  566.      pdib->iSignature = HDIB_SIGNATURE ;
  567.      pdib->hBitmap    = hBitmap ;
  568.      pdib->pBits      = pBits ;
  569.  
  570.      GetObject (hBitmap, sizeof (DIBSECTION), &pdib->ds) ;
  571.  
  572.           // Notice that we can now use the DIB information functions 
  573.           //   defined above.
  574.  
  575.           // If the compression is BI_BITFIELDS, calculate shifts from masks
  576.  
  577.      if (DibCompression (pdib) == BI_BITFIELDS)
  578.      {
  579.           for (i = 0 ; i < 3 ; i++)
  580.           {
  581.                pdib->iLShift[i] = MaskToLShift (pdib->ds.dsBitfields[i]) ;
  582.                pdib->iRShift[i] = MaskToRShift (pdib->ds.dsBitfields[i]) ;
  583.           }
  584.      }
  585.  
  586.           // If the compression is BI_RGB, but bit-count is 16 or 32,
  587.           //   set the bitfields and the masks
  588.  
  589.      else if (DibCompression (pdib) == BI_RGB)
  590.      {
  591.           if (DibBitCount (pdib) == 16)
  592.           {
  593.                pdib->ds.dsBitfields[0] = 0x00007C00 ;
  594.                pdib->ds.dsBitfields[1] = 0x000003E0 ;
  595.                pdib->ds.dsBitfields[2] = 0x0000001F ;
  596.  
  597.                pdib->iRShift[0] = 10 ;
  598.                pdib->iRShift[1] =  5 ;
  599.                pdib->iRShift[2] =  0 ; 
  600.  
  601.                pdib->iLShift[0] =  3 ;
  602.                pdib->iLShift[1] =  3 ;
  603.                pdib->iLShift[2] =  3 ;
  604.           }
  605.           else if (DibBitCount (pdib) == 24 || DibBitCount (pdib) == 32)
  606.           {
  607.                pdib->ds.dsBitfields[0] = 0x00FF0000 ;
  608.                pdib->ds.dsBitfields[1] = 0x0000FF00 ;
  609.                pdib->ds.dsBitfields[2] = 0x000000FF ;
  610.  
  611.                pdib->iRShift[0] = 16 ;
  612.                pdib->iRShift[1] =  8 ;
  613.                pdib->iRShift[2] =  0 ; 
  614.  
  615.                pdib->iLShift[0] =  0 ;
  616.                pdib->iLShift[1] =  0 ;
  617.                pdib->iLShift[2] =  0 ;
  618.           }
  619.      }
  620.           // Allocate an array of pointers to each row in the DIB
  621.  
  622.      cy = DibHeight (pdib) ;
  623.  
  624.      if (NULL == (pdib->ppRow = malloc (cy * sizeof (BYTE *))))
  625.      {
  626.           free (pdib) ;
  627.           DeleteObject (hBitmap) ;
  628.           return NULL ;
  629.      }
  630.  
  631.           // Initialize them.
  632.  
  633.      iRowLength = DibRowLength (pdib) ; 
  634.  
  635.      if (pbmi->bmiHeader.biHeight > 0)       // ie, bottom up
  636.      {
  637.           for (y = 0 ; y < cy ; y++)
  638.                pdib->ppRow[y] = pBits + (cy - y - 1) * iRowLength ;
  639.      }
  640.      else                                    // top down
  641.      {
  642.           for (y = 0 ; y < cy ; y++)
  643.                pdib->ppRow[y] = pBits + y * iRowLength ;
  644.      }
  645.      return pdib ;
  646. }
  647.  
  648. /*--------------------------------------------------
  649.    DibDelete:  Frees all memory for the DIB section
  650.   --------------------------------------------------*/
  651.  
  652. BOOL DibDelete (HDIB hdib)
  653. {
  654.      DIBSTRUCT * pdib = hdib ;
  655.  
  656.      if (!DibIsValid (hdib))
  657.           return FALSE ;
  658.  
  659.      free (pdib->ppRow) ;
  660.      DeleteObject (pdib->hBitmap) ;
  661.      free (pdib) ;
  662.      return TRUE ;
  663. }
  664.  
  665. /*----------------------------------------------------
  666.    DibCreate: Creates an HDIB from explicit arguments
  667.   ----------------------------------------------------*/ 
  668.  
  669. HDIB DibCreate (int cx, int cy, int cBits, int cColors)
  670. {
  671.      BITMAPINFO * pbmi ;
  672.      DWORD        dwInfoSize ;
  673.      HDIB         hDib ;
  674.      int          cEntries ;
  675.  
  676.      if (cx <= 0 || cy <= 0 || 
  677.          ((cBits !=  1) && (cBits !=  4) && (cBits !=  8) && 
  678.           (cBits != 16) && (cBits != 24) && (cBits != 32)))
  679.      {
  680.           return NULL ;
  681.      }
  682.  
  683.      if (cColors != 0)
  684.           cEntries = cColors ;
  685.      else if (cBits <= 8)
  686.           cEntries = 1 << cBits ;
  687.  
  688.      dwInfoSize = sizeof (BITMAPINFOHEADER) + (cEntries - 1) * sizeof (RGBQUAD);
  689.  
  690.      if (NULL == (pbmi = malloc (dwInfoSize)))
  691.      {
  692.           return NULL ;
  693.      }
  694.  
  695.      ZeroMemory (pbmi, dwInfoSize) ;
  696.  
  697.      pbmi->bmiHeader.biSize          = sizeof (BITMAPINFOHEADER) ;
  698.      pbmi->bmiHeader.biWidth         = cx ;
  699.      pbmi->bmiHeader.biHeight        = cy ;
  700.      pbmi->bmiHeader.biPlanes        = 1 ;
  701.      pbmi->bmiHeader.biBitCount      = cBits ;
  702.      pbmi->bmiHeader.biCompression   = BI_RGB ;
  703.      pbmi->bmiHeader.biSizeImage     = 0 ;
  704.      pbmi->bmiHeader.biXPelsPerMeter = 0 ;
  705.      pbmi->bmiHeader.biYPelsPerMeter = 0 ;
  706.      pbmi->bmiHeader.biClrUsed       = cColors ;
  707.      pbmi->bmiHeader.biClrImportant  = 0 ;
  708.  
  709.      hDib = DibCreateFromInfo (pbmi) ;
  710.      free (pbmi) ;
  711.  
  712.      return hDib ;
  713. }
  714.  
  715. /*--------------------------------------------------
  716.    DibCopyToInfo:  Builds BITMAPINFO structure.
  717.                    Used by DibCopy and DibCopyToDdb
  718.   --------------------------------------------------*/
  719.  
  720. static BITMAPINFO * DibCopyToInfo (HDIB hdib)
  721. {
  722.      BITMAPINFO * pbmi ;
  723.      int          i, iNumColors ;
  724.      RGBQUAD    * prgb ;
  725.  
  726.      if (!DibIsValid (hdib))
  727.           return NULL ;
  728.  
  729.           // Allocate the memory
  730.  
  731.      if (NULL == (pbmi = malloc (DibInfoSize (hdib))))
  732.           return NULL ;
  733.  
  734.           // Copy the information header
  735.  
  736.      CopyMemory (pbmi, DibInfoHeaderPtr (hdib), 
  737.                                         sizeof (BITMAPINFOHEADER));
  738.           
  739.           // Copy the possible color masks
  740.  
  741.      prgb = (RGBQUAD *) ((BYTE *) pbmi + sizeof (BITMAPINFOHEADER)) ;
  742.  
  743.      if (DibMaskSize (hdib))
  744.      {
  745.           CopyMemory (prgb, DibMaskPtr (hdib), 3 * sizeof (DWORD)) ;
  746.  
  747.           prgb = (RGBQUAD *) ((BYTE *) prgb + 3 * sizeof (DWORD)) ;
  748.      }
  749.           // Copy the color table
  750.  
  751.      iNumColors = DibNumColors (hdib) ;
  752.  
  753.      for (i = 0 ; i < iNumColors ; i++)
  754.           DibGetColor (hdib, i, prgb + i) ;
  755.  
  756.      return pbmi ;
  757. }
  758.  
  759. /*-------------------------------------------------------------------
  760.    DibCopy:  Creates a new DIB section from an existing DIB section,
  761.      possibly swapping the DIB width and height.
  762.   -------------------------------------------------------------------*/
  763.  
  764. HDIB DibCopy (HDIB hdibSrc, BOOL fRotate)
  765. {
  766.      BITMAPINFO * pbmi ;
  767.      BYTE       * pBitsSrc, * pBitsDst ;
  768.      HDIB         hdibDst ;
  769.  
  770.      if (!DibIsValid (hdibSrc))
  771.           return NULL ;
  772.  
  773.      if (NULL == (pbmi = DibCopyToInfo (hdibSrc)))
  774.           return NULL ;
  775.  
  776.      if (fRotate)
  777.      {
  778.           pbmi->bmiHeader.biWidth = DibHeight (hdibSrc) ;
  779.           pbmi->bmiHeader.biHeight = DibWidth (hdibSrc) ;
  780.      }
  781.  
  782.      hdibDst = DibCreateFromInfo (pbmi) ;
  783.      free (pbmi) ;
  784.  
  785.      if (hdibDst == NULL)
  786.           return NULL ;
  787.  
  788.           // Copy the bits
  789.  
  790.      if (!fRotate)
  791.      {
  792.           pBitsSrc = DibBitsPtr (hdibSrc) ;
  793.           pBitsDst = DibBitsPtr (hdibDst) ;
  794.  
  795.           CopyMemory (pBitsDst, pBitsSrc, DibBitsSize (hdibSrc)) ;
  796.      }
  797.      return hdibDst ;
  798. }
  799.  
  800. /*----------------------------------------------------------------------
  801.    DibCopyToPackedDib is generally used for saving DIBs and for 
  802.      transferring DIBs to the clipboard. In the second case, the second 
  803.      argument should be set to TRUE so that the memory is allocated 
  804.      with the GMEM_SHARE flag.
  805.   ----------------------------------------------------------------------*/
  806.  
  807. BITMAPINFO * DibCopyToPackedDib (HDIB hdib, BOOL fUseGlobal)
  808. {
  809.      BITMAPINFO * pPackedDib ;
  810.      BYTE       * pBits ;
  811.      DWORD        dwDibSize ;
  812.      HDC          hdcMem ;
  813.      HGLOBAL      hGlobal ;
  814.      int          iNumColors ;
  815.      PDIBSTRUCT   pdib = hdib ;
  816.      RGBQUAD    * prgb ;
  817.  
  818.      if (!DibIsValid (hdib))
  819.           return NULL ;
  820.  
  821.           // Allocate memory for packed DIB
  822.  
  823.      dwDibSize = DibTotalSize (hdib) ;
  824.  
  825.      if (fUseGlobal)
  826.      {
  827.           hGlobal = GlobalAlloc (GHND | GMEM_SHARE, dwDibSize) ;
  828.           pPackedDib = GlobalLock (hGlobal) ;
  829.      }
  830.      else
  831.      {
  832.           pPackedDib = malloc (dwDibSize) ;
  833.      }
  834.  
  835.      if (pPackedDib == NULL) 
  836.           return NULL ;
  837.  
  838.           // Copy the information header
  839.  
  840.      CopyMemory (pPackedDib, &pdib->ds.dsBmih, sizeof (BITMAPINFOHEADER)) ;
  841.  
  842.      prgb = (RGBQUAD *) ((BYTE *) pPackedDib + sizeof (BITMAPINFOHEADER)) ;
  843.  
  844.           // Copy the possible color masks
  845.  
  846.      if (pdib->ds.dsBmih.biCompression == BI_BITFIELDS)
  847.      {
  848.           CopyMemory (prgb, pdib->ds.dsBitfields, 3 * sizeof (DWORD)) ;
  849.  
  850.           prgb = (RGBQUAD *) ((BYTE *) prgb + 3 * sizeof (DWORD)) ;
  851.      }
  852.           // Copy the color table
  853.  
  854.      if (iNumColors = DibNumColors (hdib))
  855.      {
  856.           hdcMem = CreateCompatibleDC (NULL) ;
  857.           SelectObject (hdcMem, pdib->hBitmap) ;
  858.           GetDIBColorTable (hdcMem, 0, iNumColors, prgb) ;
  859.           DeleteDC (hdcMem) ;
  860.      }
  861.  
  862.      pBits = (BYTE *) (prgb + iNumColors) ;
  863.  
  864.           // Copy the bits
  865.  
  866.      CopyMemory (pBits, pdib->pBits, DibBitsSize (pdib)) ;
  867.  
  868.           // If last argument is TRUE, unlock global memory block and 
  869.           //   cast it to pointer in preparation for return
  870.  
  871.      if (fUseGlobal)
  872.      {
  873.           GlobalUnlock (hGlobal) ;
  874.           pPackedDib = (BITMAPINFO *) hGlobal ;     
  875.      }
  876.      return pPackedDib ;
  877. }
  878.  
  879. /*------------------------------------------------------------------
  880.    DibCopyFromPackedDib is generally used for pasting DIBs from the 
  881.      clipboard.
  882.   ------------------------------------------------------------------*/
  883.  
  884. HDIB DibCopyFromPackedDib (BITMAPINFO * pPackedDib)
  885. {
  886.      BYTE     * pBits ;     
  887.      DWORD      dwInfoSize, dwMaskSize, dwColorSize ;
  888.      int        iBitCount ;
  889.      PDIBSTRUCT pdib ;
  890.  
  891.           // Get the size of the information header and do validity check
  892.      
  893.      dwInfoSize = pPackedDib->bmiHeader.biSize ;
  894.  
  895.      if (dwInfoSize != sizeof (BITMAPCOREHEADER) &&
  896.          dwInfoSize != sizeof (BITMAPINFOHEADER) &&
  897.          dwInfoSize != sizeof (BITMAPV4HEADER) &&
  898.          dwInfoSize != sizeof (BITMAPV5HEADER))
  899.      {
  900.           return NULL ;
  901.      }
  902.           // Get the possible size of the color masks
  903.  
  904.      if (dwInfoSize == sizeof (BITMAPINFOHEADER) &&
  905.           pPackedDib->bmiHeader.biCompression == BI_BITFIELDS)
  906.      {
  907.           dwMaskSize = 3 * sizeof (DWORD) ;
  908.      }
  909.      else
  910.      {
  911.           dwMaskSize = 0 ;
  912.      }
  913.           // Get the size of the color table
  914.  
  915.      if (dwInfoSize == sizeof (BITMAPCOREHEADER))
  916.      {
  917.           iBitCount = ((BITMAPCOREHEADER *) pPackedDib)->bcBitCount ;
  918.  
  919.           if (iBitCount <= 8)
  920.           {
  921.                dwColorSize = (1 << iBitCount) * sizeof (RGBTRIPLE) ;
  922.           }
  923.           else
  924.                dwColorSize = 0 ;
  925.      }
  926.      else           // all non-OS/2 compatible DIBs
  927.      {
  928.           if (pPackedDib->bmiHeader.biClrUsed > 0)
  929.           {
  930.                dwColorSize = pPackedDib->bmiHeader.biClrUsed * sizeof (RGBQUAD);
  931.           }
  932.           else if (pPackedDib->bmiHeader.biBitCount <= 8)
  933.           {
  934.                dwColorSize = (1 << pPackedDib->bmiHeader.biBitCount) * 
  935.                                                        sizeof (RGBQUAD) ;
  936.           }
  937.           else
  938.           {
  939.                dwColorSize = 0 ;
  940.           }
  941.      }
  942.           // Finally, get the pointer to the bits in the packed-DIB
  943.  
  944.      pBits = (BYTE *) pPackedDib + dwInfoSize + dwMaskSize + dwColorSize ;
  945.  
  946.           // Create the HDIB from the packed DIB pointer
  947.  
  948.      pdib = DibCreateFromInfo (pPackedDib) ;
  949.  
  950.           // Copy the pixel bits
  951.  
  952.      CopyMemory (pdib->pBits, pBits, DibBitsSize (pdib)) ;
  953.  
  954.      return pdib ;
  955. }
  956.  
  957. /*-----------------------------------------------------
  958.    DibFileLoad:  Creates a DIB section from a DIB file
  959.   -----------------------------------------------------*/
  960.  
  961. HDIB DibFileLoad (const TCHAR * szFileName)
  962. {
  963.      BITMAPFILEHEADER bmfh ;
  964.      BITMAPINFO     * pbmi ;
  965.      BOOL             bSuccess ;
  966.      DWORD            dwInfoSize, dwBitsSize, dwBytesRead ;
  967.      HANDLE           hFile ;
  968.      HDIB             hDib ;
  969.  
  970.           // Open the file: read access, prohibit write access
  971.  
  972.      hFile = CreateFile (szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, 
  973.                          OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL) ;
  974.  
  975.      if (hFile == INVALID_HANDLE_VALUE)
  976.           return NULL ;
  977.  
  978.           // Read in the BITMAPFILEHEADER
  979.  
  980.      bSuccess = ReadFile (hFile, &bmfh, sizeof (BITMAPFILEHEADER), 
  981.                           &dwBytesRead, NULL) ;
  982.  
  983.      if (!bSuccess || (dwBytesRead != sizeof (BITMAPFILEHEADER))         
  984.                    || (bmfh.bfType != * (WORD *) "BM"))
  985.      {
  986.           CloseHandle (hFile) ;
  987.           return NULL ;
  988.      }
  989.           // Allocate memory for the information structure & read it in
  990.  
  991.      dwInfoSize = bmfh.bfOffBits - sizeof (BITMAPFILEHEADER) ;
  992.  
  993.      if (NULL == (pbmi = malloc (dwInfoSize)))
  994.      {
  995.           CloseHandle (hFile) ;
  996.           return NULL ;
  997.      }
  998.  
  999.      bSuccess = ReadFile (hFile, pbmi, dwInfoSize, &dwBytesRead, NULL) ;
  1000.  
  1001.      if (!bSuccess || (dwBytesRead != dwInfoSize))
  1002.      {
  1003.           CloseHandle (hFile) ;
  1004.           free (pbmi) ;
  1005.           return NULL ;
  1006.      }
  1007.           // Create the DIB
  1008.  
  1009.      hDib = DibCreateFromInfo (pbmi) ;
  1010.      free (pbmi) ;
  1011.  
  1012.      if (hDib == NULL)
  1013.      {
  1014.           CloseHandle (hFile) ;
  1015.           return NULL ;
  1016.      }
  1017.           // Read in the bits
  1018.  
  1019.      dwBitsSize = bmfh.bfSize - bmfh.bfOffBits ;
  1020.  
  1021.      bSuccess = ReadFile (hFile, ((PDIBSTRUCT) hDib)->pBits, 
  1022.                           dwBitsSize, &dwBytesRead, NULL) ;
  1023.      CloseHandle (hFile) ;
  1024.  
  1025.      if (!bSuccess || (dwBytesRead != dwBitsSize))
  1026.      {
  1027.           DibDelete (hDib) ;
  1028.           return NULL ;
  1029.      }
  1030.      return hDib ;
  1031. }
  1032.  
  1033. /*---------------------------------------------
  1034.    DibFileSave:  Saves a DIB section to a file
  1035.   ---------------------------------------------*/
  1036.  
  1037. BOOL DibFileSave (HDIB hdib, const TCHAR * szFileName)
  1038. {
  1039.      BITMAPFILEHEADER bmfh ;
  1040.      BITMAPINFO     * pbmi ;
  1041.      BOOL             bSuccess ;
  1042.      DWORD            dwTotalSize, dwBytesWritten ;
  1043.      HANDLE           hFile ;
  1044.  
  1045.      hFile = CreateFile (szFileName, GENERIC_WRITE, 0, NULL,
  1046.                          CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL) ;
  1047.  
  1048.      if (hFile == INVALID_HANDLE_VALUE)
  1049.           return FALSE ;
  1050.  
  1051.      dwTotalSize  = DibTotalSize (hdib) ;
  1052.  
  1053.      bmfh.bfType      = * (WORD *) "BM" ;
  1054.      bmfh.bfSize      = sizeof (BITMAPFILEHEADER) + dwTotalSize ;
  1055.      bmfh.bfReserved1 = 0 ;
  1056.      bmfh.bfReserved2 = 0 ;
  1057.      bmfh.bfOffBits   = bmfh.bfSize - DibBitsSize (hdib) ;
  1058.  
  1059.           // Write the BITMAPFILEHEADER
  1060.  
  1061.      bSuccess = WriteFile (hFile, &bmfh, sizeof (BITMAPFILEHEADER), 
  1062.                            &dwBytesWritten, NULL) ;
  1063.  
  1064.      if (!bSuccess || (dwBytesWritten != sizeof (BITMAPFILEHEADER)))
  1065.      {
  1066.           CloseHandle (hFile) ;
  1067.           DeleteFile (szFileName) ;
  1068.           return FALSE ;
  1069.      }
  1070.           // Get entire DIB in packed DIB format
  1071.  
  1072.      if (NULL == (pbmi = DibCopyToPackedDib (hdib, FALSE)))
  1073.      {
  1074.           CloseHandle (hFile) ;
  1075.           DeleteFile (szFileName) ;
  1076.           return FALSE ;
  1077.      }
  1078.           // Write out the packed-DIB
  1079.  
  1080.      bSuccess = WriteFile (hFile, pbmi, dwTotalSize, &dwBytesWritten, NULL) ;
  1081.      CloseHandle (hFile) ;
  1082.      free (pbmi) ;
  1083.  
  1084.      if (!bSuccess || (dwBytesWritten != dwTotalSize))
  1085.      {
  1086.           DeleteFile (szFileName) ;
  1087.           return FALSE ;
  1088.      }
  1089.      return TRUE ;
  1090. }
  1091.  
  1092. /*---------------------------------------------------
  1093.    DibCopyToDdb:  For more efficient screen displays
  1094.   ---------------------------------------------------*/
  1095.  
  1096. HBITMAP DibCopyToDdb (HDIB hdib, HWND hwnd, HPALETTE hPalette)
  1097. {
  1098.      BITMAPINFO * pbmi ;
  1099.      HBITMAP      hBitmap ;
  1100.      HDC          hdc ;
  1101.  
  1102.      if (!DibIsValid (hdib))
  1103.           return NULL ;
  1104.  
  1105.      if (NULL == (pbmi = DibCopyToInfo (hdib)))
  1106.           return NULL ;
  1107.  
  1108.      hdc = GetDC (hwnd) ;
  1109.  
  1110.      if (hPalette)
  1111.      {
  1112.           SelectPalette (hdc, hPalette, FALSE) ;
  1113.           RealizePalette (hdc) ;
  1114.      }
  1115.      
  1116.      hBitmap = CreateDIBitmap (hdc, DibInfoHeaderPtr (hdib), CBM_INIT,
  1117.                                DibBitsPtr (hdib), pbmi, DIB_RGB_COLORS) ;
  1118.  
  1119.      ReleaseDC (hwnd, hdc) ;
  1120.      free (pbmi) ;
  1121.  
  1122.      return hBitmap ;
  1123. }
  1124.